Delphi Magazine Collection 2001/Delphi Magazine Collection 20001 (2001).iso/DISKS/Issue67/construc/DrBob42_c.pas

Pascal/Delphi Source File | 2001-01-31 | 24.5 KB | 756 lines

unit DrBob42_c;

{This file was generated on 31 Jan 2001 19:59:58 GMT by version 03.03.03.C1.06}
{of the Inprise VisiBroker idl2pas CORBA IDL compiler.                        }

{Please do not edit the contents of this file. You should instead edit and    }
{recompile the original IDL which was located in the file                     }
{D:\usr\bob\magazine\DELPHI.MAG\#67\src\drbob42.idl.                          }

{Delphi Pascal unit      : DrBob42_c                                          }
{derived from IDL module : DrBob42                                            }



interface

uses
  CORBA,
  DrBob42_i;

type
  TRatesHelper = class;
  TRatesStub = class;
  TMoneyHelper = class;
  TAccountTypeHelper = class;
  TNormalAccountHelper = class;
  TNormalAccount = class;
  TSavingAccountHelper = class;
  TSavingAccount = class;
  TNormalOrSavingAccountHelper = class;
  TNormalOrSavingAccount = class;
  TAccountArrayHelper = class;
  TAccountSequenceHelper = class;
  TAccountsHelper = class;
  TAccountsStub = class;

  TRatesHelper = class
    class procedure Insert (var _A: CORBA.Any; const _Value : DrBob42_i.Rates);
    class function  Extract(var _A: CORBA.Any) : DrBob42_i.Rates;
    class function  TypeCode     : CORBA.TypeCode;
    class function  RepositoryId : string;
    class function  Read (const _Input  : CORBA.InputStream) : DrBob42_i.Rates;
    class procedure Write(const _Output : CORBA.OutputStream; const _Value : DrBob42_i.Rates);
    class function  Narrow(const _Obj   : CORBA.CORBAObject; _IsA : Boolean = False) : DrBob42_i.Rates;
    class function  Bind(const _InstanceName : string = ''; _HostName : string = '') : DrBob42_i.Rates; overload;
    class function  Bind(_Options : BindOptions; const _InstanceName : string = ''; _HostName: string = '') : DrBob42_i.Rates; overload;
  end;

  TRatesStub = class(CORBA.TCORBAObject, DrBob42_i.Rates)
  public
    function  interest_rate : Single; virtual;
    procedure SetRate ( const rate : Single); virtual;
  end;

  TMoneyHelper = class
    class procedure Insert (var   _A: CORBA.Any; const _Value : DrBob42_i.Money);
    class function  Extract(const _A: CORBA.Any): DrBob42_i.Money;
    class function  TypeCode    : CORBA.TypeCode;
    class function  RepositoryId: string;
    class function  Read (const _Input  : CORBA.InputStream) : DrBob42_i.Money;
    class procedure Write(const _Output : CORBA.OutputStream; const _Value : DrBob42_i.Money);
  end;

  TAccountTypeHelper = class
    class procedure Insert (var   _A: CORBA.Any; const _Value : DrBob42_i.AccountType);
    class function  Extract(const _A: CORBA.Any): DrBob42_i.AccountType;
    class function  TypeCode    : CORBA.TypeCode;
    class function  RepositoryId: string;
    class function  Read (const _Input  : CORBA.InputStream) : DrBob42_i.AccountType;
    class procedure Write(const _Output : CORBA.OutputStream; const _Value : DrBob42_i.AccountType);
  end;

  TNormalAccountHelper = class
    class procedure Insert (var   _A: CORBA.Any; const _Value : DrBob42_i.NormalAccount);
    class function  Extract(const _A: CORBA.Any): DrBob42_i.NormalAccount;
    class function  TypeCode    : CORBA.TypeCode;
    class function  RepositoryId: string;
    class function  Read (const _Input  : CORBA.InputStream) : DrBob42_i.NormalAccount;
    class procedure Write(const _Output : CORBA.OutputStream; const _Value : DrBob42_i.NormalAccount);
  end;

  TNormalAccount = class (TInterfacedObject, DrBob42_i.NormalAccount)
  private
    balance : DrBob42_i.Money;
    constructor Create; overload;
  public
    function  _get_balance : DrBob42_i.Money; virtual;
    procedure _set_balance ( const _value : DrBob42_i.Money ); virtual;
    constructor Create (const balance : DrBob42_i.Money
                       ); overload;
  end;

  TSavingAccountHelper = class
    class procedure Insert (var   _A: CORBA.Any; const _Value : DrBob42_i.SavingAccount);
    class function  Extract(const _A: CORBA.Any): DrBob42_i.SavingAccount;
    class function  TypeCode    : CORBA.TypeCode;
    class function  RepositoryId: string;
    class function  Read (const _Input  : CORBA.InputStream) : DrBob42_i.SavingAccount;
    class procedure Write(const _Output : CORBA.OutputStream; const _Value : DrBob42_i.SavingAccount);
  end;

  TSavingAccount = class (TInterfacedObject, DrBob42_i.SavingAccount)
  private
    balance : DrBob42_i.Money;
    rates : DrBob42_i.Rates;
    constructor Create; overload;
  public
    function  _get_balance : DrBob42_i.Money; virtual;
    procedure _set_balance ( const _value : DrBob42_i.Money ); virtual;
    function  _get_rates : DrBob42_i.Rates; virtual;
    procedure _set_rates ( const _value : DrBob42_i.Rates ); virtual;
    constructor Create (const balance : DrBob42_i.Money;
                            const rates : DrBob42_i.Rates
                       ); overload;
  end;

  TNormalOrSavingAccountHelper = class
    class procedure Insert (var   _A: CORBA.Any; const _Value : DrBob42_i.NormalOrSavingAccount);
    class function  Extract(const _A: CORBA.Any): DrBob42_i.NormalOrSavingAccount;
    class function  TypeCode    : CORBA.TypeCode;
    class function  RepositoryId: string;
    class function  Read (const _Input  : CORBA.InputStream) : DrBob42_i.NormalOrSavingAccount;
    class procedure Write(const _Output : CORBA.OutputStream; const _Value : DrBob42_i.NormalOrSavingAccount);
  end;

  TNormalOrSavingAccount = class (TInterfacedObject, DrBob42_i.NormalOrSavingAccount)
  private
    accountN : DrBob42_i.NormalAccount;
    accountS : DrBob42_i.SavingAccount;
    _discriminator : DrBob42_i.AccountType;
  public
    function  _get_accountN : DrBob42_i.NormalAccount; virtual;
    procedure _set_accountN ( const _value : DrBob42_i.NormalAccount ); virtual;
    function  _get_accountS : DrBob42_i.SavingAccount; virtual;
    procedure _set_accountS ( const _value : DrBob42_i.SavingAccount ); virtual;
    function  _get_discriminator : DrBob42_i.AccountType; virtual;
    constructor Create;
  end;

  TAccountArrayHelper = class
    class procedure Insert (var   _A: CORBA.Any; const _Value : DrBob42_i.AccountArray);
    class function  Extract(const _A: CORBA.Any): DrBob42_i.AccountArray;
    class function  TypeCode    : CORBA.TypeCode;
    class function  RepositoryId: string;
    class function  Read (const _Input  : CORBA.InputStream) : DrBob42_i.AccountArray;
    class procedure Write(const _Output : CORBA.OutputStream; const _Value : DrBob42_i.AccountArray);
  end;

  TAccountSequenceHelper = class
    class procedure Insert (var   _A: CORBA.Any; const _Value : DrBob42_i.AccountSequence);
    class function  Extract(const _A: CORBA.Any): DrBob42_i.AccountSequence;
    class function  TypeCode    : CORBA.TypeCode;
    class function  RepositoryId: string;
    class function  Read (const _Input  : CORBA.InputStream) : DrBob42_i.AccountSequence;
    class procedure Write(const _Output : CORBA.OutputStream; const _Value : DrBob42_i.AccountSequence);
  end;

  TAccountsHelper = class
    class procedure Insert (var _A: CORBA.Any; const _Value : DrBob42_i.Accounts);
    class function  Extract(var _A: CORBA.Any) : DrBob42_i.Accounts;
    class function  TypeCode     : CORBA.TypeCode;
    class function  RepositoryId : string;
    class function  Read (const _Input  : CORBA.InputStream) : DrBob42_i.Accounts;
    class procedure Write(const _Output : CORBA.OutputStream; const _Value : DrBob42_i.Accounts);
    class function  Narrow(const _Obj   : CORBA.CORBAObject; _IsA : Boolean = False) : DrBob42_i.Accounts;
    class function  Bind(const _InstanceName : string = ''; _HostName : string = '') : DrBob42_i.Accounts; overload;
    class function  Bind(_Options : BindOptions; const _InstanceName : string = ''; _HostName: string = '') : DrBob42_i.Accounts; overload;
  end;

  TAccountsStub = class(CORBA.TCORBAObject, DrBob42_i.Accounts)
  public
    procedure AccountArrayTest ( const Accounts : DrBob42_i.AccountArray); virtual;
    procedure AccountSequenceTest ( const Accounts : DrBob42_i.AccountSequence); virtual;
  end;


implementation

class procedure TRatesHelper.Insert(var _A : CORBA.Any; const _Value : DrBob42_i.Rates);
begin
  _A := Orb.MakeObjectRef( TRatesHelper.TypeCode, _Value as CORBA.CORBAObject);
end;

class function TRatesHelper.Extract(var _A : CORBA.Any): DrBob42_i.Rates;
var
  _obj : Corba.CorbaObject;
begin
  _obj := Orb.GetObjectRef(_A);
  Result := TRatesHelper.Narrow(_obj, True);
end;

class function TRatesHelper.TypeCode : CORBA.TypeCode;
begin
  Result := ORB.CreateInterfaceTC(RepositoryId, 'Rates');
end;

class function TRatesHelper.RepositoryId : string;
begin
  Result := 'IDL:DrBob42/Rates:1.0';
end;

class function TRatesHelper.Read(const _Input : CORBA.InputStream) : DrBob42_i.Rates;
var
  _Obj : CORBA.CORBAObject;
begin
  _Input.ReadObject(_Obj);
  Result := Narrow(_Obj, True)
end;

class procedure TRatesHelper.Write(const _Output : CORBA.OutputStream; const _Value : DrBob42_i.Rates);
begin
  _Output.WriteObject(_Value as CORBA.CORBAObject);
end;

class function TRatesHelper.Narrow(const _Obj : CORBA.CORBAObject; _IsA : Boolean) : DrBob42_i.Rates;
begin
  Result := nil;
  if (_Obj = nil) or (_Obj.QueryInterface(DrBob42_i.Rates, Result) = 0) then
    exit;
  if _IsA and _Obj._IsA(RepositoryId) then
    Result := TRatesStub.Create(_Obj);
end;

class function TRatesHelper.Bind(const _InstanceName : string = ''; _HostName: string = '') : DrBob42_i.Rates;
begin
  Result := Narrow(ORB.bind(RepositoryId, _InstanceName, _HostName), True);
end;

class function TRatesHelper.Bind(_Options : BindOptions; const _InstanceName : string = ''; _HostName : string = '') : DrBob42_i.Rates;
begin
  Result := Narrow(ORB.bind(RepositoryId, _Options, _InstanceName, _HostName), True);
end;

function  TRatesStub.interest_rate : Single;
var
  _Output: CORBA.OutputStream;
  _Input : CORBA.InputStream;
begin
  inherited _CreateRequest('interest_rate',True, _Output);
  inherited _Invoke(_Output, _Input);
  _Input.ReadFloat(Result);
end;

procedure TRatesStub.SetRate ( const rate : Single);
var
  _Output: CORBA.OutputStream;
  _Input : CORBA.InputStream;
begin
  inherited _CreateRequest('SetRate',True, _Output);
  _Output.WriteFloat(rate);
  inherited _Invoke(_Output, _Input);
end;

class procedure TMoneyHelper.Insert(var _A : CORBA.Any; const _Value : DrBob42_i.Money);
begin
  _A := _Value;
end;

class function TMoneyHelper.Extract(const _A : CORBA.Any) : DrBob42_i.Money;
var
  _Input : InputStream;
  _Temp  : Single;
begin
  Orb.GetAny(_A, _Input);
  _Input.ReadFloat(_Temp);
  Result := DrBob42_i.Money(_Temp);
end;

class function  TMoneyHelper.TypeCode : CORBA.TypeCode;
begin
  Result := ORB.CreateAliasTC(RepositoryId, 'Money', ORB.CreateTC(Integer(0)));
end;

class function  TMoneyHelper.RepositoryId : string;
begin
  Result := 'IDL:DrBob42/Money:1.0';
end;

class function  TMoneyHelper.Read(const _Input: CORBA.InputStream) : DrBob42_i.Money;
begin
  _Input.ReadFloat(Result);
end;

class procedure TMoneyHelper.Write(const _Output : CORBA.OutputStream; const _Value :DrBob42_i.Money);
begin
  _Output.WriteFloat(_Value);
end;

class procedure TAccountTypeHelper.Insert(var _A : CORBA.Any; const _Value : DrBob42_i.AccountType);
begin
  _A := _Value;
end;

class function TAccountTypeHelper.Extract(const _A : CORBA.Any) : DrBob42_i.AccountType;
begin
  Result := DrBob42_i.AccountType(_A);
end;

class function TAccountTypeHelper.TypeCode : CORBA.TypeCode;
begin
  Result := ORB.CreateEnumTC(RepositoryId, 'AccountType', ['normal', 'saving']);
end;

class function TAccountTypeHelper.RepositoryId: string;
begin
  Result := 'IDL:DrBob42/AccountType:1.0';
end;

class function TAccountTypeHelper.Read(const _Input : CORBA.InputStream) : DrBob42_i.AccountType;
var
  _Temp: Cardinal;
begin
  _Input.ReadULong(_Temp);
  Result := DrBob42_i.AccountType(_Temp);
end;

class procedure TAccountTypeHelper.Write(const _Output : CORBA.OutputStream; const _Value  : DrBob42_i.AccountType);
begin
  _Output.WriteULong(Cardinal(_Value));
end;

class procedure TNormalAccountHelper.Insert(var _A : CORBA.Any; const _Value : DrBob42_i.NormalAccount);
var
  _Output : CORBA.OutputStream;
begin
  _Output := ORB.CreateOutputStream;
  TNormalAccountHelper.Write(_Output, _Value);
  ORB.PutAny(_A, TNormalAccountHelper.TypeCode, _Output);
end;

class function TNormalAccountHelper.Extract(const _A : CORBA.Any) : DrBob42_i.NormalAccount;
var
  _Input : CORBA.InputStream;
begin
  Orb.GetAny(_A, _Input);
  Result := TNormalAccountHelper.Read(_Input);
end;

class function TNormalAccountHelper.TypeCode : CORBA.TypeCode;
var
  _Seq: StructMemberSeq;
begin
  SetLength(_Seq, 1);
  _Seq[0].Name := 'balance';
  _Seq[0].TC   := DrBob42_c.TMoneyHelper.TypeCode;
  Result := ORB.MakeStructureTypecode(RepositoryID, 'NormalAccount', _Seq);
end;

class function TNormalAccountHelper.RepositoryId : string;
begin
  Result := 'IDL:DrBob42/NormalAccount:1.0';
end;

class function TNormalAccountHelper.Read(const _Input : CORBA.InputStream) : DrBob42_i.NormalAccount;
var
  _Value : DrBob42_c.TNormalAccount;
begin
  _Value := DrBob42_c.TNormalAccount.Create;
  _Value.balance := DrBob42_c.TMoneyHelper.Read(_Input);
  Result := _Value;
end;

class procedure TNormalAccountHelper.Write(const _Output : CORBA.OutputStream; const _Value : DrBob42_i.NormalAccount);
begin
  DrBob42_c.TMoneyHelper.Write(_Output, _Value.balance);
end;

constructor TNormalAccount.Create;
begin
  inherited Create;
end;

constructor TNormalAccount.Create(const balance: DrBob42_i.Money);
begin
  Self.balance := balance;
end;

function  TNormalAccount._get_balance: DrBob42_i.Money;
begin
  Result := balance;
end;

procedure TNormalAccount._set_balance(const _Value : DrBob42_i.Money);
begin
  balance := _Value;
end;

class procedure TSavingAccountHelper.Insert(var _A : CORBA.Any; const _Value : DrBob42_i.SavingAccount);
var
  _Output : CORBA.OutputStream;
begin
  _Output := ORB.CreateOutputStream;
  TSavingAccountHelper.Write(_Output, _Value);
  ORB.PutAny(_A, TSavingAccountHelper.TypeCode, _Output);
end;

class function TSavingAccountHelper.Extract(const _A : CORBA.Any) : DrBob42_i.SavingAccount;
var
  _Input : CORBA.InputStream;
begin
  Orb.GetAny(_A, _Input);
  Result := TSavingAccountHelper.Read(_Input);
end;

class function TSavingAccountHelper.TypeCode : CORBA.TypeCode;
var
  _Seq: StructMemberSeq;
begin
  SetLength(_Seq, 2);
  _Seq[0].Name := 'balance';
  _Seq[0].TC   := DrBob42_c.TMoneyHelper.TypeCode;
  _Seq[1].Name := 'rates';
  _Seq[1].TC   := DrBob42_c.TRatesHelper.TypeCode;
  Result := ORB.MakeStructureTypecode(RepositoryID, 'SavingAccount', _Seq);
end;

class function TSavingAccountHelper.RepositoryId : string;
begin
  Result := 'IDL:DrBob42/SavingAccount:1.0';
end;

class function TSavingAccountHelper.Read(const _Input : CORBA.InputStream) : DrBob42_i.SavingAccount;
var
  _Value : DrBob42_c.TSavingAccount;
begin
  _Value := DrBob42_c.TSavingAccount.Create;
  _Value.balance := DrBob42_c.TMoneyHelper.Read(_Input);
  _Value.rates := DrBob42_c.TRatesHelper.Read(_Input);
  Result := _Value;
end;

class procedure TSavingAccountHelper.Write(const _Output : CORBA.OutputStream; const _Value : DrBob42_i.SavingAccount);
begin
  DrBob42_c.TMoneyHelper.Write(_Output, _Value.balance);
  DrBob42_c.TRatesHelper.Write(_Output, _Value.rates);
end;

constructor TSavingAccount.Create;
begin
  inherited Create;
end;

constructor TSavingAccount.Create(const balance: DrBob42_i.Money;
                                  const rates: DrBob42_i.Rates);
begin
  Self.balance := balance;
  Self.rates := rates;
end;

function  TSavingAccount._get_balance: DrBob42_i.Money;
begin
  Result := balance;
end;

procedure TSavingAccount._set_balance(const _Value : DrBob42_i.Money);
begin
  balance := _Value;
end;

function  TSavingAccount._get_rates: DrBob42_i.Rates;
begin
  Result := rates;
end;

procedure TSavingAccount._set_rates(const _Value : DrBob42_i.Rates);
begin
  rates := _Value;
end;

class procedure TNormalOrSavingAccountHelper.Insert(var _A : CORBA.Any; const _Value : DrBob42_i.NormalOrSavingAccount);
var
  _Output : CORBA.OutputStream;
begin
  _Output := ORB.CreateOutputStream;
  TNormalOrSavingAccountHelper.Write(_Output, _Value);
  ORB.PutAny(_A, TNormalOrSavingAccountHelper.TypeCode, _Output);
end;

class function TNormalOrSavingAccountHelper.Extract(const _A : CORBA.Any) : DrBob42_i.NormalOrSavingAccount;
var
  _Input : CORBA.InputStream;
begin
  Orb.GetAny(_A, _Input);
  Result := TNormalOrSavingAccountHelper.Read(_Input);
end;

class function TNormalOrSavingAccountHelper.TypeCode : CORBA.TypeCode;
var
  Seq: UnionMemberSeq;
begin
  SetLength(Seq, 2);
  Seq[0].Member_Name := 'accountN';
  Seq[0].Member_Label:= normal;
  Seq[0].Member_TC   := DrBob42_c.TNormalAccountHelper.TypeCode;
  Seq[1].Member_Name := 'accountS';
  Seq[1].Member_Label:= saving;
  Seq[1].Member_TC   := DrBob42_c.TSavingAccountHelper.TypeCode;
  Result := ORB.CreateUnionTC(RepositoryID, 'NormalOrSavingAccount', DrBob42_c.TAccountTypeHelper.TypeCode, Seq);
end;

class function TNormalOrSavingAccountHelper.RepositoryId: string;
begin
  Result := 'IDL:DrBob42/NormalOrSavingAccount:1.0';
end;

class function TNormalOrSavingAccountHelper.Read(const _Input: CORBA.InputStream): DrBob42_i.NormalOrSavingAccount;
var
  _Value : DrBob42_c.TNormalOrSavingAccount;
  _Temp  : Integer;
begin
  _Value := TNormalOrSavingAccount.Create;
  _Input.ReadLong(_Temp);
  _Value._discriminator := DrBob42_i.AccountType(_Temp);
  case _Value._discriminator of
    normal : _Value.accountN := DrBob42_c.TNormalAccountHelper.Read(_Input);
    saving : _Value.accountS := DrBob42_c.TSavingAccountHelper.Read(_Input);
  end;
  Result := _Value;
end;

class procedure TNormalOrSavingAccountHelper.Write(const _Output : CORBA.OutputStream; const _Value : DrBob42_i.NormalOrSavingAccount);
var
  temp  : Integer;
begin
  temp := Integer(_Value._discriminator);
  _Output.WriteLong(temp);
  case _Value._discriminator of
    normal : DrBob42_c.TNormalAccountHelper.Write(_Output, _Value.accountN);
    saving : DrBob42_c.TSavingAccountHelper.Write(_Output, _Value.accountS);
  end;
end;

constructor TNormalOrSavingAccount.Create;
begin
  Self._discriminator := DrBob42_i.AccountType(normal);
end;

function  TNormalOrSavingAccount._get_discriminator: DrBob42_i.AccountType;
begin
  Result := _discriminator;
end;

function  TNormalOrSavingAccount._get_accountN: DrBob42_i.NormalAccount;
begin
  if ( ( _discriminator <> normal )
      )
    then raise BAD_OPERATION.Create(0, COMPLETED_YES);
  Result := accountN;
end;

procedure TNormalOrSavingAccount._set_accountN(const _Value : DrBob42_i.NormalAccount);
begin
  _discriminator := normal;
  accountN := _Value;
end;

function  TNormalOrSavingAccount._get_accountS: DrBob42_i.SavingAccount;
begin
  if ( ( _discriminator <> saving )
      )
    then raise BAD_OPERATION.Create(0, COMPLETED_YES);
  Result := accountS;
end;

procedure TNormalOrSavingAccount._set_accountS(const _Value : DrBob42_i.SavingAccount);
begin
  _discriminator := saving;
  accountS := _Value;
end;

class procedure TAccountArrayHelper.Insert(var _A: CORBA.Any; const _Value : DrBob42_i.AccountArray);
var
  _Output : CORBA.OutputStream;
begin
  _Output := ORB.CreateOutputStream;
  TAccountArrayHelper.Write(_Output, _Value);
  ORB.PutAny(_A, TAccountArrayHelper.TypeCode, _Output);
end;

class function  TAccountArrayHelper.Extract(const _A : CORBA.Any): DrBob42_i.AccountArray;
var
  _Input : CORBA.InputStream;
begin
  Orb.GetAny(_A, _Input);
  Result := TAccountArrayHelper.Read(_Input);
end;

class function  TAccountArrayHelper.TypeCode: CORBA.TypeCode;
begin
  Result := ORB.CreateArrayTC(3, DrBob42_c.TNormalOrSavingAccountHelper.TypeCode());
end;

class function  TAccountArrayHelper.RepositoryId: string;
begin
  Result := 'IDL:DrBob42/AccountArray:1.0';
end;

class function  TAccountArrayHelper.Read(const _Input: CORBA.InputStream) : DrBob42_i.AccountArray;
var
  I0 : Cardinal;
begin
  for I0 := 0 to 2 do
  begin
    Result[I0] := DrBob42_c.TNormalOrSavingAccountHelper.Read(_Input);
  end;
end;

class procedure TAccountArrayHelper.Write(const _Output: CORBA.OutputStream; const _Value: DrBob42_i.AccountArray);
var
  I0 : Cardinal;
begin
  for I0 := 0 to 2 do
  begin
    DrBob42_c.TNormalOrSavingAccountHelper.Write(_Output, _Value[I0]);
  end;
end;

class procedure TAccountSequenceHelper.Insert(var _A : CORBA.Any; const _Value : DrBob42_i.AccountSequence);
var
  _Output : CORBA.OutputStream;
begin
  _Output := ORB.CreateOutputStream;
  TAccountSequenceHelper.Write(_Output, _Value);
  ORB.PutAny(_A, TAccountSequenceHelper.TypeCode, _Output);
end;

class function TAccountSequenceHelper.Extract(const _A : CORBA.Any): DrBob42_i.AccountSequence;
var
  _Input : InputStream;
begin
  Orb.GetAny(_A, _Input);
  Result := TAccountSequenceHelper.Read(_Input);
end;

class function  TAccountSequenceHelper.TypeCode: CORBA.TypeCode;
begin
  Result := ORB.CreateSequenceTC(0, DrBob42_c.TNormalOrSavingAccountHelper.TypeCode());
end;

class function  TAccountSequenceHelper.RepositoryId: string;
begin
  Result := 'IDL:DrBob42/AccountSequence:1.0';
end;

class function  TAccountSequenceHelper.Read(const _Input : CORBA.InputStream) : DrBob42_i.AccountSequence;
var
  L0 : Cardinal;
  I0 : Cardinal;
begin
  _Input.ReadULong(L0);
  SetLength(Result, L0);
  if (L0 > 0) then
  begin
    for I0 := 0 to High(Result) do
    begin
      Result[I0] := DrBob42_c.TNormalOrSavingAccountHelper.Read(_Input);
    end;
  end;
end;

class procedure TAccountSequenceHelper.Write(const _Output: CORBA.OutputStream; const _Value: DrBob42_i.AccountSequence);
var
  L0 : Cardinal;
  I0 : Cardinal;
begin
  L0 := Length(_Value);
  _Output.WriteULong(L0);
  if (L0 > 0) then
  begin
    for I0 := 0 to High(_Value) do
    begin
      DrBob42_c.TNormalOrSavingAccountHelper.Write(_Output, _Value[I0]);
    end;
  end;
end;

class procedure TAccountsHelper.Insert(var _A : CORBA.Any; const _Value : DrBob42_i.Accounts);
begin
  _A := Orb.MakeObjectRef( TAccountsHelper.TypeCode, _Value as CORBA.CORBAObject);
end;

class function TAccountsHelper.Extract(var _A : CORBA.Any): DrBob42_i.Accounts;
var
  _obj : Corba.CorbaObject;
begin
  _obj := Orb.GetObjectRef(_A);
  Result := TAccountsHelper.Narrow(_obj, True);
end;

class function TAccountsHelper.TypeCode : CORBA.TypeCode;
begin
  Result := ORB.CreateInterfaceTC(RepositoryId, 'Accounts');
end;

class function TAccountsHelper.RepositoryId : string;
begin
  Result := 'IDL:DrBob42/Accounts:1.0';
end;

class function TAccountsHelper.Read(const _Input : CORBA.InputStream) : DrBob42_i.Accounts;
var
  _Obj : CORBA.CORBAObject;
begin
  _Input.ReadObject(_Obj);
  Result := Narrow(_Obj, True)
end;

class procedure TAccountsHelper.Write(const _Output : CORBA.OutputStream; const _Value : DrBob42_i.Accounts);
begin
  _Output.WriteObject(_Value as CORBA.CORBAObject);
end;

class function TAccountsHelper.Narrow(const _Obj : CORBA.CORBAObject; _IsA : Boolean) : DrBob42_i.Accounts;
begin
  Result := nil;
  if (_Obj = nil) or (_Obj.QueryInterface(DrBob42_i.Accounts, Result) = 0) then
    exit;
  if _IsA and _Obj._IsA(RepositoryId) then
    Result := TAccountsStub.Create(_Obj);
end;

class function TAccountsHelper.Bind(const _InstanceName : string = ''; _HostName: string = '') : DrBob42_i.Accounts;
begin
  Result := Narrow(ORB.bind(RepositoryId, _InstanceName, _HostName), True);
end;

class function TAccountsHelper.Bind(_Options : BindOptions; const _InstanceName : string = ''; _HostName : string = '') : DrBob42_i.Accounts;
begin
  Result := Narrow(ORB.bind(RepositoryId, _Options, _InstanceName, _HostName), True);
end;

procedure TAccountsStub.AccountArrayTest ( const Accounts : DrBob42_i.AccountArray);
var
  _Output: CORBA.OutputStream;
  _Input : CORBA.InputStream;
begin
  inherited _CreateRequest('AccountArrayTest',True, _Output);
  DrBob42_c.TAccountArrayHelper.Write(_Output, Accounts);
  inherited _Invoke(_Output, _Input);
end;

procedure TAccountsStub.AccountSequenceTest ( const Accounts : DrBob42_i.AccountSequence);
var
  _Output: CORBA.OutputStream;
  _Input : CORBA.InputStream;
begin
  inherited _CreateRequest('AccountSequenceTest',True, _Output);
  DrBob42_c.TAccountSequenceHelper.Write(_Output, Accounts);
  inherited _Invoke(_Output, _Input);
end;


initialization


end.